/*
 * @Author: liu_lizhi
 * @Date: 2021-03-23 17:02:35
 * @LastEditTime: 2021-08-20 15:36:19
 * @Description: 公共类
 */
import Constant from './constant'
import FileUtils from './fileUtil'
import Config from './config'
import request from './request'

// import CryptoJS from 'crypto-js'

var baseUtil = {
	/*
	   * 判断应用当前运行在手机还是PC
	   */
	isPcOrMobile: function () {
		var f = Constant.PTMO_PUBLIC_SORT.RUN_ENV.PC
		var sUserAgent = navigator.userAgent.toLowerCase()
		var bIsIpad = sUserAgent.match(/ipad/i) == 'ipad',
			bIsIphoneOs = sUserAgent.match(/iphone os/i) == 'iphone os',
			bIsMidp = sUserAgent.match(/midp/i) == 'midp',
			bIsUc7 = sUserAgent.match(/rv:1.2.3.4/i) == 'rv:1.2.3.4',
			bIsUc = sUserAgent.match(/ucweb/i) == 'ucweb',
			bIsAndroid = sUserAgent.match(/android/i) == 'android',
			bIsCE = sUserAgent.match(/windows ce/i) == 'windows ce',
			bIsWM = sUserAgent.match(/windows mobile/i) == 'windows mobile'

		if (bIsIpad || bIsIphoneOs || bIsMidp || bIsUc7 || bIsUc || bIsAndroid || bIsCE || bIsWM) {
			f = Constant.PTMO_PUBLIC_SORT.RUN_ENV.MOBILE
		}
		return f
	},

	/**
	 * @description: 生成url
	 * @param {*}
	 * @return {*}
	 */
	downloadFileblob: function (params) {
		return window.URL.createObjectURL(new Blob([params.data], {
			type: "video/mp4"
		}))
	},
	/**
	  * 验证文本是否为空
	  * @param valParam 参数名
	  *  return  true/false
	  */
	isEmptyString: function (valParam) {
		if (valParam == null || valParam === '' || valParam === 'null' || valParam == undefined) {
			return true
		} else {
			return false
		}
	},
	
	pageBack: function() {
		history.go(-1);
	},
	/**
	   * 生成6位随机数
	   *
	   */
	buildSixNum: function () {
		var max = 999999
		var min = 100000
		return Math.floor(Math.random() * (max - min + 1) + min)
	},
	/**
	   * 根据类型获取目录路径
	   * @param {Object} type
	   * @param {Object} suncess
	   */
	getFilePath: function (type, success, fail) {
		var directoryPath = ''
		if (type == Constant.PTMO_PUBLIC_SORT.PATH_TYPE.LOG) {
			directoryPath = Config.LOG_PATH
		} else if (type == Constant.PTMO_PUBLIC_SORT.PATH_TYPE.APK) {
			directoryPath = Config.APK_PATH
		} else if (type == Constant.PTMO_PUBLIC_SORT.PATH_TYPE.SMALL_PIC) {
			directoryPath = Config.SMALL_PIC_PATH
		} else if (type == Constant.PTMO_PUBLIC_SORT.PATH_TYPE.MIDIUM_PIC) {
			directoryPath = Config.MIDIUM_PIC_PATH
		} else if (type == Constant.PTMO_PUBLIC_SORT.PATH_TYPE.ORIGINAL_PIC) {
			directoryPath = Config.ORIGINAL_PIC_PATH
		} else if (type == Constant.PTMO_PUBLIC_SORT.PATH_TYPE.DEFAULT_PIC) {
			directoryPath = Config.DEFAULT_PIC_PATH
		} else if (type == Constant.PTMO_PUBLIC_SORT.PATH_TYPE.AUDIO) {
			directoryPath = Config.AUDIO_PATH
		} else if (type == Constant.PTMO_PUBLIC_SORT.PATH_TYPE.FILE) {
			directoryPath = Config.FILE_PATH
		} else if (type == Constant.PTMO_PUBLIC_SORT.PATH_TYPE.DAT) {
			directoryPath = Config.DAT_PATH
		}

		// console.log("打印directoryPath：" + directoryPath)
		if (baseUtil.isPcOrMobile() == 'pc') {
			FileUtils.createFloderPCMethod(directoryPath, function (dirEntry) {
				console.log("打印getFilePath文件路径如下：")
				console.log(dirEntry)
				success(dirEntry)
			}, function () {
				fail()
			})
		} else {
			FileUtils.createFloderMethod(directoryPath, function (dirEntry) {
				success(dirEntry)
			}, function () {
				fail()
			})
		}
	},
	UUIDcreatePart: function (length) {
		var uuidpart = '';
		for (var i = 0; i < length; i++) {
			var uuidchar = parseInt((Math.random() * 256), 10).toString(16);
			if (uuidchar.length === 1) {
				uuidchar = '0' + uuidchar;
			}
			uuidpart += uuidchar;
		}
		return uuidpart;
	},
	/**
	  * 生成UUID 42位
	  * 根据以下规则生成UUID 时间+"-"+IMEI+"-" +随机数
	  */
	buildUUID: function () {
		var uuid = ''
		var max = 9999999999
		var min = 1000000000
		var currentTime = getFormatDateByLong(new Date().getTime(), 'yyyyMMddhhmmss') // 14
		uuid = currentTime + '-' + Math.floor(Math.random() * (max - min + 1) + min)
		return uuid
	},
	/**
	 * @description: 生成uuid(图片上传)
	 * @return {*} uuid
	 */
	createUUID() {
		return baseUtil.UUIDcreatePart(4) + '-' +
			baseUtil.UUIDcreatePart(2) + '-' +
			baseUtil.UUIDcreatePart(2) + '-' +
			baseUtil.UUIDcreatePart(2) + '-' +
			baseUtil.UUIDcreatePart(6);
	},
	/**
	 * @description: 创建所有的目录
	 */
	createAllFloder: function () {
		var path = [Config.LOG_PATH, Config.APK_PATH, Config.SMALL_PIC_PATH, Config.MIDIUM_PIC_PATH, Config.ORIGINAL_PIC_PATH, Config.DEFAULT_PIC_PATH, Config.AUDIO_PATH, Config.FILE_PATH];
		var successNum = 0;
		var failNum = 0;

		return new Promise((resolve, reject) => {
			if (baseUtil.isPcOrMobile() == "pc") {
				for (var i = 0; i < path.length; i++) {
					FileUtils.createFloderPCMethod(path[i], function () {
						successNum++;
					}, function () {
						reject();
					});
				}
			} else {
				for (var i = 0; i < path.length; i++) {
					FileUtils.createFloderMethod(path[i], function () {
						successNum++;
					}, function () {
						reject();
					});
				}
			}
			var time = setInterval(function () {
				if (successNum == path.length) {
					clearInterval(time);
					resolve();
				}
				if (failNum > 0) {
					clearInterval(time);
					reject();
				}
			}, 100);
		})
	},
	removeRepeatedItem: function (arr, attrs) {
		// 属性名数组为空
		if (attrs == undefined || attrs == null || !(arr instanceof Array) || attrs.length == 0) {
			for (var i = arr.length - 1; i > 0; i--) {
				for (var j = i - 1; j >= 0; j--) {
					if (arr[i] == arr[j]) {
						arr.splice(i, 1);
					}
				}
			}
		}
		else {
			var isTheSame = true;
			for (var i = arr.length - 1; i > 0; i--) {
				for (var j = i - 1; j >= 0; j--) {
					// 对每个元素进行判断
					isTheSame = true;
					for (var k = 0; k < attrs.length; k++) {
						if (!baseUtil.hasTheAttribute(arr[i], attrs[k])
							&& baseUtil.hasTheAttribute(arr[j], attrs[k])
							|| baseUtil.hasTheAttribute(arr[i], attrs[k])
							&& !baseUtil.hasTheAttribute(arr[j], attrs[k])
							|| baseUtil.hasTheAttribute(arr[i], attrs[k])
							&& baseUtil.hasTheAttribute(arr[j], attrs[k])
							&& arr[i][attrs[k]] != arr[j][attrs[k]]) {
							isTheSame = false;
						}
					}
					if (isTheSame) {
						arr.splice(i, 1);
					}
				}
			}
		}
	},
	//查询字典值保存在本地
	getAllCodeList: function () {
		request.post('/task/dictionary/getDictionary', { userId: "915142429", roleCode: "" })
			.then(response => {
				if (response.success) {
					localStorage.setItem("allSortCode", JSON.stringify(response.data));
				} else {
					Message.fail(response.msg)
				}
			}).catch(err => {
				Message.fail(err)
			})
	},
	/**
	 * @description: 获取指定类型字典值
	 * @param {*} code编码类型 例如 缺陷来源 DEFECT_SOURCE
	 * @return {*}
	 */
	getSpecialCode: function (code) {
		var codeId = "", codeList = [];
		var allSortCode = localStorage.getItem("allSortCode");
		if (baseUtil.isEmptyString(allSortCode)) {
			return codeList;
		}
		allSortCode = JSON.parse(allSortCode);
		for (var codeItem of allSortCode) {
			if (codeItem.code == code) {
				codeId = codeItem.id;
			}
		}
		if (!baseUtil.isEmptyString(codeId)) {
			for (var codeItem of allSortCode) {
				if (codeItem.parentId == codeId) {
					codeList.push(codeItem);
				}
			}
		}
		return codeList;
	},
	/**
	 * @description: 将base64转换为file类型
	 * @param {*} dataurl base64
	 * @return {*}
	 */
	dataUrlToFile: function (dataurl) {
		if (!dataurl) return
		let arr = dataurl.split(','),
			mime = arr[0].match(/:(.*?);/)[1],
			bstr = atob(arr[1]),
			n = bstr.length,
			u8arr = new Uint8Array(n);
		while (n--) {
			u8arr[n] = bstr.charCodeAt(n);
		}
		return new Blob([u8arr], {
			type: mime
		});
	},
	/**
	 * 判断一个对象是否有指定的属性
	 * @param {Object} obj 对象，传入空的时候返回false
	 * @param {Object} attrName 属性名，传入空的时候返回false
	 */
	hasTheAttribute: function (obj, attrName) {
		if (obj == undefined || obj == null) {
			return false;
		}
		if (baseUtil.isEmptyString(attrName)) {
			return false;
		}

		for (var key in obj) {
			if (key === attrName) {
				return true;
			}
		}
		return false;
	},
	/**
	 * 检查字符串实际长度
	 * @param {String} str 字符串
	 */
	charCodeLength(str) {
		return str.replace(/[\u0391-\uFFF5]/g, 'll').length;
	},
	/**
	 * @description: 从自己模块跳转到其他模块
	 * @param {string} moduleName 需要跳转的模块地址
	 * @param {object} params 需要跳转的到指定模块需要携带的参数
	 */
	goToOtherMoudule: function (moduleName, params) {
		// moduleName {moduleName#}/{routePath} 例如 /defect#/DefectAdd 这样/defect是自己的模块文件名称/#默认，再加上/DefectAdd这个是模块某个页面的路由

		// params = {
		//   moduleName:"", // 来自哪个模块，必传参数，否则无法处理相应参数值
		//   markId: "", //作业卡MarkID
		//   taskId: "", // 任务id
		// }
		let queryParam = "";
		// 参数转化为数组
		Object.keys(params).forEach(Element => {
			queryParam += Element + "=" + params[Element] + "&"
		})

		var a = document.createElement('a');
		a.href = moduleName + "?" + queryParam;

		if (baseUtil.isPcOrMobile() == Constant.PTMO_PUBLIC_SORT.RUN_ENV.MOBILE) {
			// 只在移动端操作
			// "file:///android_asset/www/" + 模块名 + 主页入口html#/路由? + 参数 
			var index = a.href.indexOf('www')
			var url = a.href.slice(0, index + 4) + moduleName + "/index.html#/{0}?" + queryParam;
			if (params.routerPath) {
				//如果 有路由地址，则拼接
				url = url.replace(/\{0\}/, params.routerPath)
			} else {
				url = url.replace(/\{0\}/, '')
			}
			console.log('url：' + url)
			a.href = url
		} else {
			//其它处理:从平台模块跳转时会存在多余一项目录导致无法正常跳转
			if (moduleName != 'platform') {
				var searchIndex = a.href.indexOf('platform')
				if (searchIndex > -1) {
					a.href = a.href.replace('platform/', '')
				}
			}
		}
		a.click(); // 触发a标签
		a.remove(); // 清除a标签
	},
	/**
	 * @description: 获取用户登录信息
	 * @param {*} callback
	 * @return {*}
	 */
	getUserInfo: function (callback) {
		// 用户信息格式化
		var userInfo = {
			user: null,
			orgId: null,
			orgName: null,
			unitId: null,
			unitName: null,
			substationId: null,
			substationName: null,
			roleCode: null,
			roleName: null,
			teamList: []
		}
		try {
			// 安卓登录后-调用安卓代码获取用户信息返回
			tpf.platformclient.getUserInfo(function (data) {
				try {
					if (typeof data == "string") {
						userInfo.user = JSON.parse(data)
					} else {
						userInfo.user = data
					}
					//用户信息中已经包含用户班组、用户角色属性，不需要再调用getDefaultOrg方法
					userInfo.orgId = userInfo.user.orgDTO.orgId
					userInfo.orgName = userInfo.user.orgDTO.orgName
					// 地市id
					userInfo.unitId = userInfo.user.orgDTO.unitId
					userInfo.unitName = userInfo.user.orgDTO.unitName
					// 角色编码
					userInfo.roleCode = userInfo.user.roleDTO.roleCode
					userInfo.roleName = userInfo.user.roleDTO.roleName
					// 为减少各页面引入修改量，单独处理把对象修改为数组
					var obj = {
						orgId: userInfo.orgId,
						orgName: userInfo.orgName
					}
					userInfo.teamList = [obj]
				} catch (error) {
				}
				console.log('用户成功返回，信息' + JSON.stringify(userInfo.user))
				var success = function (type, res) {
					// 暂时注释，以防后期返回此种格式
					// if (type == 1) {
					// 	console.log('用户班级' + JSON.stringify(res))
					// 	userInfo.orgId = res.orgId
					// 	userInfo.orgName = res.orgName
					// 	try {
					// 		if (typeof res.roleList == "string") {
					// 			userInfo.roleList = JSON.parse(res.roleList)
					// 		} else {
					// 			userInfo.roleList = res.roleList
					// 		}
					// 		if (typeof res.teamList == "string") {
					// 			userInfo.teamList = JSON.parse(res.teamList)
					// 		} else {
					// 			userInfo.teamList = res.teamList
					// 		}
					// 	} catch (error) {
					// 	}
					// }
					if (type == 2) {
						console.log('用户变电站到' + JSON.stringify(res))
						userInfo.substationId = res.substationId
						userInfo.substationName = res.substationName
						console.log('用户所选变电站名称:' + res.substationName)
					}
					if (userInfo.orgId != null && userInfo.substationId != null) {
						callback(userInfo)
					}
				}
				var fail = function (err) {
					callback(userInfo)
					console.log('获取信息失败' + err)
				}

				//baseUtil.getDefaultOrg(success, fail)
				baseUtil.getDefaultSubstation(success, fail)
			}, function (err) {
				callback(userInfo)
				console.log('用户失败返回' + JSON.stringify(err))
			})
		} catch (e) {
			callback(userInfo)
			console.log('用户信息转换失败' + e)
		}

		//配置默认选择的班组信息
		// userInfo.orgId = localStorage.orgId || userInfo.orgId
		// userInfo.orgName = localStorage.orgName || userInfo.orgName
	},
	/**
	 * @description: 获取用户选择班组信息
	 * @param {*}  success
	 * @param {*}  fail
	 * @return {*}
	 */
	getDefaultOrg: function (success, fail) {
		// 安卓登录后-调用安卓代码获取用户信息返回
		// 不存在时从android端获取班组信息
		tpf.platformclient.getDefaultOrg(function (data) {
			console.log('获取班组成功返回' + JSON.stringify(data))

			success(1, data)
		}, function (err) {
			fail(err)
			console.log('获取班组失败返回' + JSON.stringify(err))
		})
	},
	/**
	* @description: 获取用户选择变电站信息
	* @param {*}  success
	* @param {*}  fail
	* @return {*}
	*/
	getDefaultSubstation: function (success, fail) {
		// 用户变电站信息格式化
		var substaionInfo = null
		// 安卓登录后-调用安卓代码获取用户信息返回
		// 不存在时从android端获取用户信息
		tpf.platformclient.getDefaultSubstation(function (data) {
			console.log('获取变电站成功返回' + JSON.stringify(data))

			success(2, data)
		}, function (err) {
			fail(err)
			console.log('获取变电站失败返回' + JSON.stringify(err))
		})
	},
	/**
	 * @description: ecb加密
	 * @param {*} word 加密串
	 * @param {*} keyStr 加密盐
	 * @return {*} 加密后值
	 */
	encrypt: function (word, keyStr) {
		keyStr = keyStr ? keyStr : "Frontier"
		let key = CryptoJS.enc.Utf8.parse(keyStr)
		let encrypted = CryptoJS.DES.encrypt(word, key, {
			mode: CryptoJS.mode.ECB,
			padding: CryptoJS.pad.Pkcs7
		})

		return encrypted.toString()
	},
	/**
	 * @description: ecb解密
	 * @param {*} word 加密串
	 * @param {*} keyStr 解密盐
	 * @return {*} 解密后值
	 */
	decrypt: function (word, keyStr) {
		keyStr = keyStr ? keyStr : "Frontier"
		let key = CryptoJS.enc.Utf8.parse(keyStr)
		let decrypt = CryptoJS.DES.decrypt(word, key, {
			mode: CryptoJS.mode.ECB,
			padding: CryptoJS.pad.Pkcs7
		})

		return CryptoJS.enc.Utf8.stringify(decrypt).toString()
	}
}

/**
 * 时间格式化
 * @param format 时间格式
 * @returns {*}
 */
Date.prototype.format = function (format) {
	var o = {
		'M+': this.getMonth() + 1,
		'd+': this.getDate(),
		'h+': this.getHours(),
		'm+': this.getMinutes(),
		's+': this.getSeconds(),
		'q+': Math.floor((this.getMonth() + 3) / 3),
		'S': this.getMilliseconds()
	}
	if (/(y+)/.test(format)) {
		format = format.replace(RegExp.$1, (this.getFullYear() + '').substr(4 - RegExp.$1.length))
	}
	for (var k in o) {
		if (new RegExp('(' + k + ')').test(format)) {
			format = format.replace(RegExp.$1, RegExp.$1.length == 1 ? o[k] : ('00' + o[k]).substr(('' + o[k]).length))
		}
	}

	return format
}

function isEmptyString(valParam) {
	if (valParam == null || valParam === '' || valParam == undefined) {
		return true
	} else {
		return false
	}
}

/**
 *转换日期对象为日期字符串
 * @param date 时间
 * @param pattern 格式字符串,例如：yyyy-MM-dd hh:mm:ss, 默认为yyyy-MM-dd hh:mm:ss
 * @return 符合要求的日期字符串
 */
function getFormatDate(date, pattern) {
	try {
		if (isEmptyString(date)) {
			return ''
		}
		if (isEmptyString(pattern)) {
			pattern = 'yyyy-MM-dd hh:mm:ss'
		}
		return date.format(pattern)
	} catch (e) {
		console.log('时间转换失败，time:' + date.date + ',format:' + date.format)
		return date
	}
}
/**
 * @description: 根据参数减去指定月返回开始日期
 * @param {*} count = 1 月数
 * @return {*} 返回开始日期
 */
function getIncrDecrDate(count) {
	count = count ? count : 0
	var beforeDate = new Date();
	beforeDate.setMonth(beforeDate.getMonth() - count);
	// console.log('返回日期',beforeDate.toLocaleDateString())
	return getFormatDateByLong(beforeDate, "yyyy-MM-dd");
}
/**
 * @description: 根据参数减去指定日返回开始时间
 * @param {*} count = 1 天数
 * @return {*} 返回开始时间
 */
function getIncrDecrTime(count) {
	var count = count ? count : 1
	var beforeDate = new Date();
	beforeDate.setDate(beforeDate.getDate() - count);
	// console.log('返回时间',beforeDate.toLocaleDateString())
	return getFormatDateByLong(beforeDate, "yyyy-MM-dd hh:mm:ss");
}

/**
 * 转换long值为日期字符串
 * @param longDate long值时间
 * @param pattern 格式字符串,例如：yyyy-MM-dd hh:mm:ss
 * @return 符合要求的日期字符串
 */
function getFormatDateByLong(longDate, pattern) {
	try {
		if (longDate === undefined || longDate == null) {
			return ''
		}
		return getFormatDate(new Date(longDate), pattern)
	} catch (e) {
		console.log('LONG时间转换失败，time:' + longDate + ',format:' + format)
	}
	return ''
}

var sortCode = {
	/**
	 * 根据编码分类、编码值获取编码名（同步方式调用）
	 * @param {Object} sortCode 编码分类
	 * @param {Object} code 编码值
	 */
	getCodeName: function (sortCode, code) {
		var codeName = null;
		var sortCodes = JSON.parse(localStorage.getItem("sortCodes")) || []
		for (var i = 0; i < sortCodes.length; i++) {
			if (sortCodes[i].sortCode == sortCode && sortCodes[i].code == code) {
				codeName = sortCodes[i].name;
			}
		}
		return codeName;
	},
	/**
	 * 根据编码分类、编码值获取编码备注
	 * @param {Object} sortCode 编码分类
	 * @param {Object} code 编码值
	 */
	getCodeRemark: function (sortCode, code) {
		var codeName = null;
		var sortCodes = JSON.parse(localStorage.getItem("sortCodes")) || []
		for (var i = 0; i < sortCodes.length; i++) {
			if (sortCodes[i].sortCode == sortCode && sortCodes[i].code == code) {
				codeName = sortCodes[i].sortRemark;
			}
		}
		return codeName;
	},
	/**
	 * 根据编码分类、编码名获取编码值
	 * @param {Object} sortCode 编码分类
	 * @param {Object} name 编码名
	 */
	getCode: function (sortCode, name) {
		var code = null;
		var sortCodes = JSON.parse(localStorage.getItem("sortCodes")) || []
		for (var i = 0; i < sortCodes.length; i++) {
			if (sortCodes[i].sortCode == sortCode && sortCodes[i].name == name) {
				code = sortCodes[i].code;
			}
		}
		return code;
	},
	/**
	 * 根据编码分类获取编码列表,失败时返回空数组
	 * @param {Object} sortCode 编码分类
	 */
	getSortCode: function (sortCode) {
		// console.log("根据编码分类获取编码列表—开始");
		var codes = [];
		var sortCodes = JSON.parse(localStorage.getItem("sortCodes")) || []
		for (var i = 0; i < sortCodes.length; i++) {
			if (sortCodes[i].sortCode == sortCode) {
				codes.push(sortCodes[i]);
			}
		}
		return codes;
	},
};

var fileUtil = {
	/*
	 * 上传文件的公共方法
	 *
	 * 【必填】bizData 上传数据
	 *
	 *  bizData:{
	 * 	filePath:"/storage/sdcard0/ptmo/data/file/XXX.jpg ",    //（字符型） 【必填参数】上传的文件路径
	 *  fileUuid:"xxxxxxxxx" 为方便离线操作，终端上传的Uuid使用本地生成 
	 *  sourceType: 1,2,3,4,5,6,7,8 【必填参数】上传的文件来源，即模块  1-运维，2-验收，3-检修，4-检测，5-操作票，6-评价，7-缺陷 ，8-公共模块
	 *  validateType: "picture、..." -暂时未做文件格式判定,后续添加
	 * }
	 */
	fileUpload: function (bizData) {
		// 做文件类操作检查
		return new Promise((resolve, reject) => {
			//三个参数空校验
			if (baseUtil.isEmptyString(bizData.filePath)) {
				console.log("【fileUpload】文件上传  - 参数验证失败：filePath不可为空，")
				reject("文件地址不可为空");
				return false;
			}
			if (baseUtil.isEmptyString(bizData.fileUuid)) {
				console.log("【fileUpload】文件上传  - 参数验证失败：fileUuid不可为空")
				reject("文件UUID不可为空");
				return false;
			}
			if (baseUtil.isEmptyString(bizData.sourceType)) {
				console.log("【fileUpload】文件上传  - 参数验证失败：sourceType不可为空")
				reject("文件来源不可为空");
				return false;
			}

			//判断文件的格式
			// if (!baseUtil.isEmptyString(bizData.validateType)) {
			//   var validateState = validateFileType(bizData.validateType, [bizData.filePath], failed);
			//   if (validateState == false) {
			//     console.log("【文件上传】  -  验证文件上传的格式不正确");
			//     reject("文件格式不正确!");
			//     return false;
			//   }
			// }

			//输出上传相关参数
			console.log("打印fileUuid:" + bizData.fileUuid)
			console.log("打印filePath:" + bizData.filePath)
			console.log("打印sourceType:" + bizData.sourceType)
			//截取文件路径获取后缀
			var fileNamePath = bizData.filePath.split(".");
			var fileExe = fileNamePath[fileNamePath.length - 1];
			// 去除前缀file://
			bizData.filePath = bizData.filePath.replace("file://", "")
			// 判断上传文件是否存在
			window.requestFileSystem(LocalFileSystem.PERSISTENT, 0,
				function (fileSystem) {
					//输出上传相关参数
					console.log("打印fileUuid:" + bizData.fileUuid)
					console.log("打印filePath:" + bizData.filePath)
					// 根据文件路径获得文件
					//检查用
					var tmpFile = bizData.filePath.slice(19)
					//console.log('新文件地址：' + tmpFile);
					fileSystem.root.getFile(tmpFile, {
						create: false,
						exclusive: false
					}, function (fileEntry) {
						console.log("【文件上传】  - 文件存在,返回文件路径");
						// 获得配置的文件路径
						baseUtil.getFilePath(Constant.PTMO_PUBLIC_SORT.PATH_TYPE.FILE, function (dirEntry) {
							var fileFloder = dirEntry.fullPath;
							// 复制文件到指定路径
							fileEntry.copyTo(dirEntry, bizData.fileUuid + "." + fileExe, function () {
								console.log("【文件上传】  - 文件复制成功");
							}, function () {
								console.log("【文件上传】  - 文件复制失败");
							});
						},
							function () {
								console.log("文件上传  - 获取文件路径失败");
								reject("获取文件路径失败");
								return false;
							});
						// 定义并设置：本机的imei号
						var imei = deviceInfo.getDeviceIMEL();

						console.log("【文件上传】 - 打印bizData信息" + JSON.stringify(bizData));
						// 调用上传文件的接口
						androidUploadEntry(bizData).then(res => {
							console.log("【文件上传】 - 文件上传成功，" + JSON.stringify(res));
							resolve(res);
						}).catch(error => {
							console.log("【文件上传】 - 文件上传失败" + JSON.stringify(error));
							reject(error)
						})
					}, function (error) {
						console.log("【文件上传】 - 上传时未找到对应的文件" + JSON.stringify(error));
						reject("上传时未找到对应的文件")
						return false;
					});
				},
				function () {
					console.log("【文件上传】 - 获取requestFileSystem对象失败");
					reject("系统未访问到本地路径");
					return false;
				});
		})
	},
	/**
	  * @description: 文件下载
	  * @param {*} uuid 文件uuid
	  * @param {*} saveName 文件名
	  * @param {*} fileType 文件类型：指的是保存在哪个位置
	  * @return {*}
	  */
	downloadFile: function (uuid, saveName, fileType) {
		return new Promise((resolve, reject) => {
			//测试语句，只在pc端使用
			if (baseUtil.isPcOrMobile() == 'pc') {
				setTimeout(() => {
					resolve({ uuid: '111', nativePath: 'test.jpg' })
				}, 1000);
				return;
			}

			if (baseUtil.isEmptyString(uuid)) {
				console.log("【downloadFile下载文件】参数错误- uuid不可为空");
				reject("参数错误,uuid不可为空")
				return false;
			}

			if (baseUtil.isEmptyString(fileType)) {
				console.log("【downloadFile下载文件】参数错误- fileType不可为空");
				reject("参数错误,fileType不可为空")
				return false;
			}

			if (baseUtil.isEmptyString(saveName)) {
				console.log("【downloadFile下载文件】参数错误- saveName不可为空");
				reject("参数错误,saveName不可为空")
				return false;
			}
			if (fileType != Constant.PTMO_PUBLIC_SORT.PATH_TYPE.LOG &&
				fileType != Constant.PTMO_PUBLIC_SORT.PATH_TYPE.APK &&
				fileType != Constant.PTMO_PUBLIC_SORT.PATH_TYPE.AUDIO &&
				fileType != Constant.PTMO_PUBLIC_SORT.PATH_TYPE.DEFAULT_PIC &&
				fileType != Constant.PTMO_PUBLIC_SORT.PATH_TYPE.FILE) {
				console.log("【downloadFile下载文件】参数错误- fileType不符合要求");
				reject("参数错误,fileType不符合要求")
				return false;
			}
			// 获得文件下载保存的路径
			var fileFloder;
			baseUtil.getFilePath(fileType, function (dirEntry) {
				var sysPath = device.sysPath;
				var filePathDirArray = [];
				fileFloder = device.sysPath + dirEntry.fullPath;
				//下载使用的包参数
				var bizData = {
					fileUuid: uuid, //文件uuid
					fileName: saveName, //文件名
					fileType: fileType, //文件类型
					downPath: fileFloder, //文件存放文件夹位置
					fullPath: dirEntry.fullPath, //文件全地址
					filePathDirArray: [] //文件目录-用于检查文件是否存在
				}
				console.log(JSON.stringify(bizData));

				// 判断文件是否存在-后期可能需要补充完整各种类型
				if (fileType == Constant.PTMO_PUBLIC_SORT.PATH_TYPE.AUDIO) {
					filePathDirArray.push(Config.AUDIO_PATH);
				} else if (fileType == Constant.PTMO_PUBLIC_SORT.PATH_TYPE.DEFAULT_PIC) {
					filePathDirArray.push(Config.DEFAULT_PIC_PATH);
				} else {
					filePathDirArray.push(Config.FILE_PATH);
				}
				bizData.filePathDirArray = filePathDirArray;
				//成功返回
				var success = function (result) {
					// console.log('下载成功' + JSON.stringify(result))
					resolve(result)
				}
				//失败返回
				var failed = function (err) {
					console.log('[下载]失败' + JSON.stringify(err))
					reject(err)
				}
				checkFileExist(bizData, success, failed);
			}, function () {
				console.log("【下载】  - 获得文件下载保存的路径失败");
				reject("获得文件下载保存的路径失败")
				return false;
			});
		})
	},

};

/*
  * 递归检查文件是否存在，如果不存在就下载文件，如果存在返回文件路径
  *
  *  bizData  业务参数
  *  success   成功回调
  *  failed    失败回调
  * */
var recursionNum = 0;
function checkFileExist(bizData, success, failed) {
	// console.log("【checkFileExist 检索文件是否存在】   - 开始递归查询本地文件 recursionNum=" + recursionNum);
	//获取需要搜索本地的文件路径集合
	var filePathDirArray = bizData.filePathDirArray;
	var findName = bizData.findName;

	window.requestFileSystem(LocalFileSystem.PERSISTENT, 0, function (fileSystem) {
		//查询获得文件目录
		// console.log("【查询获得文件目录】   - filePathDirArray[0] =" +filePathDirArray[recursionNum]);
		fileSystem.root.getDirectory(filePathDirArray[recursionNum], {
			create: false,
			exclusive: false
		},
			function (dirEntry) {
				//获得查询的目录对象
				var dirReader = dirEntry.createReader();
				// console.log("【检索文件是否存在】   - 获取阅读的权限");
				//读取文件夹下的所有文件和文件夹
				dirReader.readEntries(function (results) {
					for (var i = 0; i < results.length; i++) {
						var entrie = results[i];
						var fileName = entrie.name;
						var fileNameExt = entrie.name.split(".");
						// console.log("【检索文件是否存在】   - 查询文件夹小的文件，fileName+" + fileName);
						//如果是文件夹，直接过滤
						if (entrie.isDirectory) {
							// console.log("【检索文件是否存在】   - 是否是文件夹=" + entrie.isDirectory);
							continue;
						}
						//判断查找的文件名是否在查找结果中
						if (fileName.indexOf(findName) == -1) {
							// console.log("【检索文件是否存在】   - 是否名字包含其中" + fileName);
							continue;
						}
						//过滤出文件不带.后缀的文件
						if (fileNameExt.length < 2) {
							// console.log("【检索文件是否存在】   - 名字和后缀小于2 " + fileNameExt.length);
							continue;
						}
						// console.log("【检索文件是否存在】   - 找到文件，打印文件路径" + entrie.fullPath);

						var pathObj = {
							fullPath: entrie.fullPath,
							nativePath: device.sysPath + "" + entrie.fullPath,
							uuid: bizData.uuid
						};
						success(pathObj);
						recursionNum = 0;
						//返回跳出方法体循环
						return;
					}
					//console.log("【检索文件是否存在】   - 打印recursionNum的值= " + recursionNum);
					if (recursionNum < filePathDirArray.length - 1) {
						recursionNum++;
						// console.log("【检索文件是否存在】   - 没找到文件，继续递归");
						checkFileExist(bizData, success, failed);
					} else {
						recursionNum = 0;
						//调用android方法下载文件
						// console.log("【检索文件是否存在】 - 本地搜索过，仍然无相同文件，开始从后台下载");
						androidDownloadEntry(bizData).then(res => {
							// console.log("【文件下载】 - 文件下载成功，" + JSON.stringify(res));
							success(res);
						}).catch(error => {
							console.log("【文件下载】 - 文件下载失败" + JSON.stringify(error));
							failed(error)
						})
					}
				}, function () {
					recursionNum = 0;
					// console.log("【检索文件是否存在】   - 读取文件夹内容失败");
				});
			},
			function (err) {
				console.log(JSON.stringify(err))
				recursionNum = 0;
				// console.log("【检索文件是否存在】   - 获取文件目录失败");
			});
	}, function () {
		recursionNum = 0;
		// console.log("【检索文件是否存在】   - 获取系统文件访问权限失败");
	});
}

/**
 * js与安卓联接下载入口
 * @param requestEntity 请求实体
 */
function androidDownloadEntry(requestEntity) {
	// 后期可以做基本请求检查
	return new Promise((resolve, reject) => {
		tpf.platformclient.fileDownload(requestEntity, function (result) {
			// 正常返回
			// console.log('[下载]请求正常返回' + JSON.stringify(result))
			resolve(result)
		}, function (error) {
			// 异常
			console.log('[下载]请求错误返回' + JSON.stringify(error))
			reject(error)
		})
	})
}

/**
 * js与安卓联接上传入口
 * @param requestEntity 请求实体
 */
function androidUploadEntry(requestEntity) {
	// 后期可以做基本请求检查
	return new Promise((resolve, reject) => {
		tpf.platformclient.fileUpload(requestEntity, function (result) {
			// 正常返回
			// console.log('[上传]请求正常返回' + JSON.stringify(result))
			resolve(result)
		}, function (error) {
			// 异常
			console.log('[上传]请求错误返回' + JSON.stringify(error))
			reject(error)
		})
	})
}

/**
 * 设备有关的公共方法
 */
var deviceInfo = {
	/**
	 * 获取手机的IMEI 16位
	 */
	getDeviceIMEL: function () {
		var imei = "";
		var max = 99999999999999;
		var min = 10000000000000;
		var isPc = baseUtil.isPcOrMobile();
		var localImei = localStorage.getItem("IMEI");
		if (localImei == null || localImei == "" || localImei == "undefine") {
			if (isPc == "pc") {
				imei = "PC" + Math.floor(Math.random() * (max - min + 1) + min);
			} else {
				imei = device.imei;
			}
		} else {
			imei = localImei;
		}
		if (imei.length == 15) {
			imei = imei + "0";
		}
		return imei;
	},
	/**
	 * 获取手机序列号SN 16位
	 */
	getSerialNumber: function () {
		var SN = "";
		var max = 99999999999999;
		var min = 10000000000000;
		var isPc = baseUtil.isPcOrMobile();
		if (isPc == "pc") {
			SN = "PC" + Math.floor(Math.random() * (max - min + 1) + min);
		} else {
			SN = device.serialnumber;
		}
		return SN;
	},
	/**
	 * 判断nfc是否打开 true打开 false没有打开或者没有nfc功能
	 */
	isOpenNfc: function () {
		return device.nfc;
	},
	/**
	 * 判断gps是否打开 true打开 false没有打开
	 */
	isOpenGps: function () {
		return device.gps;
	},
	/**
	 * 获取当前音乐音量
	 */
	getCurrentVolume: function () {
		return device.currentVolume;
	},
	/**
	 * 当前的音乐音量不要小于设定的值
	 * 小于设定的值 返回false
	 */
	isUnderSetData: function () {
		var setData = device.currentMaxVolume * Constant.PTMO_PUBLIC_SORT.VOLUME_SET_DATA.VOLUME;
		if (device.currentVolume < setData) {
			return false;
		} else {
			return true;
		}
	},
	/**
	 * 判断蓝牙是否打开
	 * true 打开 false 未打开
	 */
	isOpenBlueTooth: function () {
		return device.bluetooth;
	},
	/**
	 * 判断网络是否连接
	 */
	netIsConnect: function () {
		return device.netIsConnected;
	}
}

const DateUtil = {
	getFormatDateByLong: getFormatDateByLong,
	getFormatDate: getFormatDate,
	getIncrDecrDate: getIncrDecrDate,
	getIncrDecrTime: getIncrDecrTime
}


export default {
	DateUtil,
	baseUtil,
	fileUtil,
	deviceInfo,
	sortCode
}
